package nav

/*
#include<stdint.h>
#include<stdbool.h>
extern void * nav_dtTileCacheAlloc_alloc(void * c_this,unsigned long long size);
extern void nav_dtTileCacheAlloc_Delete(void * c_this);
extern void nav_dtTileCacheAlloc_DeleteArray(void * c_this);
extern void* nav_NewdtTileCacheAlloc();
extern void nav_dtTileCacheAlloc_free(void * c_this,void * ptr);
extern void * nav_dtTileCacheAlloc_IndexArray(void * c_this,long n);
extern void nav_dtTileCacheAlloc_reset(void * c_this);
extern unsigned int nav_dtTileCacheCompressor_compress(void * c_this,void * buffer,int bufferSize,void * compressed,int maxCompressedSize,void * compressedSize);
extern unsigned int nav_dtTileCacheCompressor_decompress(void * c_this,void * compressed,int compressedSize,void * buffer,int maxBufferSize,void * bufferSize);
extern void nav_dtTileCacheCompressor_Delete(void * c_this);
extern int nav_dtTileCacheCompressor_maxCompressedSize(void * c_this,int bufferSize);
extern void nav_dtTileCacheContour_Delete(void * c_this);
extern void nav_dtTileCacheContour_DeleteArray(void * c_this);
extern void* nav_NewdtTileCacheContour();
extern void * nav_dtTileCacheContour_GetPtrToArea(void * c_this);
extern void * nav_dtTileCacheContour_GetPtrToNverts(void * c_this);
extern void * nav_dtTileCacheContour_GetPtrToReg(void * c_this);
extern void * nav_dtTileCacheContour_GetPtrToVerts(void * c_this);
extern void * nav_dtTileCacheContour_IndexArray(void * c_this,long n);
extern void nav_dtTileCacheContourSet_Delete(void * c_this);
extern void nav_dtTileCacheContourSet_DeleteArray(void * c_this);
extern void* nav_NewdtTileCacheContourSet();
extern void * nav_dtTileCacheContourSet_GetPtrToConts(void * c_this);
extern void * nav_dtTileCacheContourSet_GetPtrToNconts(void * c_this);
extern void * nav_dtTileCacheContourSet_IndexArray(void * c_this,long n);
extern void nav_dtTileCacheLayer_Delete(void * c_this);
extern void nav_dtTileCacheLayer_DeleteArray(void * c_this);
extern void* nav_NewdtTileCacheLayer();
extern void * nav_dtTileCacheLayer_GetPtrToAreas(void * c_this);
extern void * nav_dtTileCacheLayer_GetPtrToCons(void * c_this);
extern void * nav_dtTileCacheLayer_GetPtrToHeader(void * c_this);
extern void * nav_dtTileCacheLayer_GetPtrToHeights(void * c_this);
extern void * nav_dtTileCacheLayer_GetPtrToRegCount(void * c_this);
extern void * nav_dtTileCacheLayer_GetPtrToRegs(void * c_this);
extern void * nav_dtTileCacheLayer_IndexArray(void * c_this,long n);
extern void nav_dtTileCacheLayerHeader_Delete(void * c_this);
extern void nav_dtTileCacheLayerHeader_DeleteArray(void * c_this);
extern void* nav_NewdtTileCacheLayerHeader();
extern void * nav_dtTileCacheLayerHeader_GetPtrToBmax(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToBmin(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToHeight(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToHmax(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToHmin(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToMagic(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToMaxx(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToMaxy(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToMinx(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToMiny(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToTlayer(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToTx(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToTy(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToVersion(void * c_this);
extern void * nav_dtTileCacheLayerHeader_GetPtrToWidth(void * c_this);
extern void * nav_dtTileCacheLayerHeader_IndexArray(void * c_this,long n);
extern void nav_dtTileCachePolyMesh_Delete(void * c_this);
extern void nav_dtTileCachePolyMesh_DeleteArray(void * c_this);
extern void* nav_NewdtTileCachePolyMesh();
extern void * nav_dtTileCachePolyMesh_GetPtrToAreas(void * c_this);
extern void * nav_dtTileCachePolyMesh_GetPtrToFlags(void * c_this);
extern void * nav_dtTileCachePolyMesh_GetPtrToNpolys(void * c_this);
extern void * nav_dtTileCachePolyMesh_GetPtrToNverts(void * c_this);
extern void * nav_dtTileCachePolyMesh_GetPtrToNvp(void * c_this);
extern void * nav_dtTileCachePolyMesh_GetPtrToPolys(void * c_this);
extern void * nav_dtTileCachePolyMesh_GetPtrToVerts(void * c_this);
extern void * nav_dtTileCachePolyMesh_IndexArray(void * c_this,long n);
extern void * nav_dtAllocTileCacheContourSet(void * alloc);
extern void * nav_dtAllocTileCachePolyMesh(void * alloc);
extern unsigned int nav_dtBuildTileCacheContours(void * alloc,void * layer,int walkableClimb,float maxError,void * lcset);
extern unsigned int nav_dtBuildTileCacheLayer(void * comp,void * header,void * heights,void * areas,void * cons,void * outData,void * outDataSize);
extern unsigned int nav_dtBuildTileCachePolyMesh(void * alloc,void * lcset,void * mesh);
extern unsigned int nav_dtBuildTileCacheRegions(void * alloc,void * layer,int walkableClimb);
extern unsigned int nav_dtDecompressTileCacheLayer(void * alloc,void * comp,void * compressed,int compressedSize,void * layerOut);
extern void nav_dtFreeTileCacheContourSet(void * alloc,void * cset);
extern void nav_dtFreeTileCacheLayer(void * alloc,void * layer);
extern void nav_dtFreeTileCachePolyMesh(void * alloc,void * lmesh);
extern unsigned int nav_dtMarkBoxArea(void * layer,void * orig,float cs,float ch,void * bmin,void * bmax,unsigned char areaId);
extern unsigned int nav_dtMarkBoxArea11(void * layer,void * orig,float cs,float ch,void * center,void * halfExtents,void * rotAux,unsigned char areaId);
extern unsigned int nav_dtMarkCylinderArea(void * layer,void * orig,float cs,float ch,void * pos,float radius,float height,unsigned char areaId);
extern bool nav_dtTileCacheHeaderSwapEndian(void * data,int dataSize);
extern void * nav_NewDtTileCacheAllocPtrArray(long n);
extern void * nav_NewDtTileCacheContourPtrArray(long n);
extern void * nav_NewDtTileCacheContourSetPtrArray(long n);
extern void * nav_NewDtTileCacheLayerHeaderPtrArray(long n);
extern void * nav_NewDtTileCacheLayerPtrArray(long n);
extern void * nav_NewDtTileCachePolyMeshPtrArray(long n);

*/
import "C"
import "unsafe"
import "gitee.com/hasika/cgo"

var _ unsafe.Pointer
var _ cgo.NotUsed

type DtTileCacheAllocPtr uintptr

/*
public virtual void * alloc(size_t const size)
*/
func (p DtTileCacheAllocPtr) Alloc(size uint64) uintptr {
	var wrap_this unsafe.Pointer
	var wrap_arg_size C.ulonglong
	wrap_this = unsafe.Pointer(p)
	wrap_arg_size = (C.ulonglong)(size)
	wrap_out := C.nav_dtTileCacheAlloc_alloc(wrap_this, wrap_arg_size)
	go_out := (uintptr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public virtual void Delete()
*/
func (p DtTileCacheAllocPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheAlloc_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCacheAllocPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheAlloc_DeleteArray(wrap_this)
}

/*
public dtTileCacheAlloc()
*/
func NewDtTileCacheAlloc() cgo.GoManagedPtr[DtTileCacheAllocPtr] {
	wrap_out := C.nav_NewdtTileCacheAlloc()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCacheAllocPtr]](uintptr(wrap_out))
	return go_out
}

/*
public virtual void free(void * ptr)
*/
func (p DtTileCacheAllocPtr) Free(ptr uintptr) {
	var wrap_this unsafe.Pointer
	var wrap_arg_ptr unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ptr = (unsafe.Pointer)(ptr)
	C.nav_dtTileCacheAlloc_free(wrap_this, wrap_arg_ptr)
}

/*
dtTileCacheAlloc * IndexArray(long n)
*/
func (p DtTileCacheAllocPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheAlloc_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public virtual void reset()
*/
func (p DtTileCacheAllocPtr) Reset() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheAlloc_reset(wrap_this)
}

type DtTileCacheCompressorPtr uintptr

/*
public virtual dtStatus compress(unsigned char const * buffer, int const bufferSize, unsigned char * compressed, int const maxCompressedSize, int * compressedSize) = 0
*/
func (p DtTileCacheCompressorPtr) Compress(buffer *uint8, bufferSize int32, compressed *uint8, maxCompressedSize int32, compressedSize *int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_buffer unsafe.Pointer
	var wrap_arg_bufferSize C.int
	var wrap_arg_compressed unsafe.Pointer
	var wrap_arg_maxCompressedSize C.int
	var wrap_arg_compressedSize unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_buffer = (unsafe.Pointer)(buffer)
	wrap_arg_bufferSize = (C.int)(bufferSize)
	wrap_arg_compressed = (unsafe.Pointer)(compressed)
	wrap_arg_maxCompressedSize = (C.int)(maxCompressedSize)
	wrap_arg_compressedSize = (unsafe.Pointer)(compressedSize)
	wrap_out := C.nav_dtTileCacheCompressor_compress(wrap_this, wrap_arg_buffer, wrap_arg_bufferSize, wrap_arg_compressed, wrap_arg_maxCompressedSize, wrap_arg_compressedSize)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public virtual dtStatus decompress(unsigned char const * compressed, int const compressedSize, unsigned char * buffer, int const maxBufferSize, int * bufferSize) = 0
*/
func (p DtTileCacheCompressorPtr) Decompress(compressed *uint8, compressedSize int32, buffer *uint8, maxBufferSize int32, bufferSize *int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_compressed unsafe.Pointer
	var wrap_arg_compressedSize C.int
	var wrap_arg_buffer unsafe.Pointer
	var wrap_arg_maxBufferSize C.int
	var wrap_arg_bufferSize unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_compressed = (unsafe.Pointer)(compressed)
	wrap_arg_compressedSize = (C.int)(compressedSize)
	wrap_arg_buffer = (unsafe.Pointer)(buffer)
	wrap_arg_maxBufferSize = (C.int)(maxBufferSize)
	wrap_arg_bufferSize = (unsafe.Pointer)(bufferSize)
	wrap_out := C.nav_dtTileCacheCompressor_decompress(wrap_this, wrap_arg_compressed, wrap_arg_compressedSize, wrap_arg_buffer, wrap_arg_maxBufferSize, wrap_arg_bufferSize)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public virtual void Delete()
*/
func (p DtTileCacheCompressorPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheCompressor_Delete(wrap_this)
}

/*
public virtual int maxCompressedSize(int const bufferSize) = 0
*/
func (p DtTileCacheCompressorPtr) MaxCompressedSize(bufferSize int32) int32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_bufferSize C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_bufferSize = (C.int)(bufferSize)
	wrap_out := C.nav_dtTileCacheCompressor_maxCompressedSize(wrap_this, wrap_arg_bufferSize)
	go_out := int32(wrap_out)
	return go_out
}

type DtTileCacheContourPtr uintptr

/*
public void Delete()
*/
func (p DtTileCacheContourPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheContour_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCacheContourPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheContour_DeleteArray(wrap_this)
}

/*
public dtTileCacheContour()
*/
func NewDtTileCacheContour() cgo.GoManagedPtr[DtTileCacheContourPtr] {
	wrap_out := C.nav_NewdtTileCacheContour()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCacheContourPtr]](uintptr(wrap_out))
	return go_out
}

/*
public unsigned char * GetPtrToArea()
*/
func (p DtTileCacheContourPtr) GetPtrToArea() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheContour_GetPtrToArea(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToNverts()
*/
func (p DtTileCacheContourPtr) GetPtrToNverts() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheContour_GetPtrToNverts(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * GetPtrToReg()
*/
func (p DtTileCacheContourPtr) GetPtrToReg() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheContour_GetPtrToReg(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * * GetPtrToVerts()
*/
func (p DtTileCacheContourPtr) GetPtrToVerts() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheContour_GetPtrToVerts(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtTileCacheContour * IndexArray(long n)
*/
func (p DtTileCacheContourPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheContour_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtTileCacheContourSetPtr uintptr

/*
public void Delete()
*/
func (p DtTileCacheContourSetPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheContourSet_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCacheContourSetPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheContourSet_DeleteArray(wrap_this)
}

/*
public dtTileCacheContourSet()
*/
func NewDtTileCacheContourSet() cgo.GoManagedPtr[DtTileCacheContourSetPtr] {
	wrap_out := C.nav_NewdtTileCacheContourSet()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCacheContourSetPtr]](uintptr(wrap_out))
	return go_out
}

/*
public dtTileCacheContour * * GetPtrToConts()
*/
func (p DtTileCacheContourSetPtr) GetPtrToConts() *DtTileCacheContourPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheContourSet_GetPtrToConts(wrap_this)
	go_out := (*DtTileCacheContourPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToNconts()
*/
func (p DtTileCacheContourSetPtr) GetPtrToNconts() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheContourSet_GetPtrToNconts(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtTileCacheContourSet * IndexArray(long n)
*/
func (p DtTileCacheContourSetPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheContourSet_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtTileCacheLayerPtr uintptr

/*
public void Delete()
*/
func (p DtTileCacheLayerPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheLayer_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCacheLayerPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheLayer_DeleteArray(wrap_this)
}

/*
public dtTileCacheLayer()
*/
func NewDtTileCacheLayer() cgo.GoManagedPtr[DtTileCacheLayerPtr] {
	wrap_out := C.nav_NewdtTileCacheLayer()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCacheLayerPtr]](uintptr(wrap_out))
	return go_out
}

/*
public unsigned char * * GetPtrToAreas()
*/
func (p DtTileCacheLayerPtr) GetPtrToAreas() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayer_GetPtrToAreas(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * * GetPtrToCons()
*/
func (p DtTileCacheLayerPtr) GetPtrToCons() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayer_GetPtrToCons(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public dtTileCacheLayerHeader * * GetPtrToHeader()
*/
func (p DtTileCacheLayerPtr) GetPtrToHeader() *DtTileCacheLayerHeaderPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayer_GetPtrToHeader(wrap_this)
	go_out := (*DtTileCacheLayerHeaderPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * * GetPtrToHeights()
*/
func (p DtTileCacheLayerPtr) GetPtrToHeights() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayer_GetPtrToHeights(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Region count.

public unsigned char * GetPtrToRegCount()
*/
func (p DtTileCacheLayerPtr) GetPtrToRegCount() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayer_GetPtrToRegCount(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public unsigned char * * GetPtrToRegs()
*/
func (p DtTileCacheLayerPtr) GetPtrToRegs() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayer_GetPtrToRegs(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtTileCacheLayer * IndexArray(long n)
*/
func (p DtTileCacheLayerPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayer_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtTileCacheLayerHeaderPtr uintptr

/*
public void Delete()
*/
func (p DtTileCacheLayerHeaderPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheLayerHeader_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCacheLayerHeaderPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCacheLayerHeader_DeleteArray(wrap_this)
}

/*
public dtTileCacheLayerHeader()
*/
func NewDtTileCacheLayerHeader() cgo.GoManagedPtr[DtTileCacheLayerHeaderPtr] {
	wrap_out := C.nav_NewdtTileCacheLayerHeader()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCacheLayerHeaderPtr]](uintptr(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToBmax()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToBmin()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Dimension of the layer.

public unsigned char * GetPtrToHeight()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToHeight() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToHeight(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Height minmax range

public unsigned short * GetPtrToHmax()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToHmax() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToHmax(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Height minmax range

public unsigned short * GetPtrToHmin()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToHmin() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToHmin(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Data magic

public int * GetPtrToMagic()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToMagic() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToMagic(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Usable sub-region.

public unsigned char * GetPtrToMaxx()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToMaxx() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToMaxx(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Usable sub-region.

public unsigned char * GetPtrToMaxy()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToMaxy() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToMaxy(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Usable sub-region.

public unsigned char * GetPtrToMinx()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToMinx() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToMinx(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Usable sub-region.

public unsigned char * GetPtrToMiny()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToMiny() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToMiny(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToTlayer()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToTlayer() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToTlayer(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToTx()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToTx() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToTx(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToTy()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToTy() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToTy(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Data version

public int * GetPtrToVersion()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToVersion() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToVersion(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Dimension of the layer.

public unsigned char * GetPtrToWidth()
*/
func (p DtTileCacheLayerHeaderPtr) GetPtrToWidth() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_GetPtrToWidth(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtTileCacheLayerHeader * IndexArray(long n)
*/
func (p DtTileCacheLayerHeaderPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCacheLayerHeader_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtTileCachePolyMeshPtr uintptr

/*
public void Delete()
*/
func (p DtTileCachePolyMeshPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCachePolyMesh_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtTileCachePolyMeshPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtTileCachePolyMesh_DeleteArray(wrap_this)
}

/*
public dtTileCachePolyMesh()
*/
func NewDtTileCachePolyMesh() cgo.GoManagedPtr[DtTileCachePolyMeshPtr] {
	wrap_out := C.nav_NewdtTileCachePolyMesh()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtTileCachePolyMeshPtr]](uintptr(wrap_out))
	return go_out
}

/*
Area ID of polygons.

public unsigned char * * GetPtrToAreas()
*/
func (p DtTileCachePolyMeshPtr) GetPtrToAreas() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCachePolyMesh_GetPtrToAreas(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Per polygon flags.

public unsigned short * * GetPtrToFlags()
*/
func (p DtTileCachePolyMeshPtr) GetPtrToFlags() **uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCachePolyMesh_GetPtrToFlags(wrap_this)
	go_out := (**uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Number of polygons.

public int * GetPtrToNpolys()
*/
func (p DtTileCachePolyMeshPtr) GetPtrToNpolys() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCachePolyMesh_GetPtrToNpolys(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Number of vertices.

public int * GetPtrToNverts()
*/
func (p DtTileCachePolyMeshPtr) GetPtrToNverts() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCachePolyMesh_GetPtrToNverts(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public int * GetPtrToNvp()
*/
func (p DtTileCachePolyMeshPtr) GetPtrToNvp() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCachePolyMesh_GetPtrToNvp(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Polygons of the mesh, nvp*2 elements per polygon.

public unsigned short * * GetPtrToPolys()
*/
func (p DtTileCachePolyMeshPtr) GetPtrToPolys() **uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCachePolyMesh_GetPtrToPolys(wrap_this)
	go_out := (**uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Vertices of the mesh, 3 elements per vertex.

public unsigned short * * GetPtrToVerts()
*/
func (p DtTileCachePolyMeshPtr) GetPtrToVerts() **uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCachePolyMesh_GetPtrToVerts(wrap_this)
	go_out := (**uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtTileCachePolyMesh * IndexArray(long n)
*/
func (p DtTileCachePolyMeshPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtTileCachePolyMesh_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
dtTileCacheContourSet * dtAllocTileCacheContourSet(dtTileCacheAlloc * alloc)
*/
func DtAllocTileCacheContourSet(alloc DtTileCacheAllocPtr) DtTileCacheContourSetPtr {
	var wrap_arg_alloc unsafe.Pointer
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_out := C.nav_dtAllocTileCacheContourSet(wrap_arg_alloc)
	go_out := cgo.MakePtr[DtTileCacheContourSetPtr](uintptr(wrap_out))
	return go_out
}

/*
dtTileCachePolyMesh * dtAllocTileCachePolyMesh(dtTileCacheAlloc * alloc)
*/
func DtAllocTileCachePolyMesh(alloc DtTileCacheAllocPtr) DtTileCachePolyMeshPtr {
	var wrap_arg_alloc unsafe.Pointer
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_out := C.nav_dtAllocTileCachePolyMesh(wrap_arg_alloc)
	go_out := cgo.MakePtr[DtTileCachePolyMeshPtr](uintptr(wrap_out))
	return go_out
}

/*
dtStatus dtBuildTileCacheContours(dtTileCacheAlloc * alloc, dtTileCacheLayer& layer, int const walkableClimb, float const maxError, dtTileCacheContourSet& lcset)
*/
func DtBuildTileCacheContours(alloc DtTileCacheAllocPtr, layer DtTileCacheLayerPtr, walkableClimb int32, maxError float32, lcset DtTileCacheContourSetPtr) uint32 {
	var wrap_arg_alloc unsafe.Pointer
	var wrap_arg_layer unsafe.Pointer
	var wrap_arg_walkableClimb C.int
	var wrap_arg_maxError C.float
	var wrap_arg_lcset unsafe.Pointer
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_arg_layer = (unsafe.Pointer)(layer)
	wrap_arg_walkableClimb = (C.int)(walkableClimb)
	wrap_arg_maxError = (C.float)(maxError)
	wrap_arg_lcset = (unsafe.Pointer)(lcset)
	wrap_out := C.nav_dtBuildTileCacheContours(wrap_arg_alloc, wrap_arg_layer, wrap_arg_walkableClimb, wrap_arg_maxError, wrap_arg_lcset)
	go_out := uint32(wrap_out)
	return go_out
}

/*
dtStatus dtBuildTileCacheLayer(dtTileCacheCompressor * comp, dtTileCacheLayerHeader * header, unsigned char const * heights, unsigned char const * areas, unsigned char const * cons, unsigned char * * outData, int * outDataSize)
*/
func DtBuildTileCacheLayer(comp DtTileCacheCompressorPtr, header DtTileCacheLayerHeaderPtr, heights *uint8, areas *uint8, cons *uint8, outData **uint8, outDataSize *int32) uint32 {
	var wrap_arg_comp unsafe.Pointer
	var wrap_arg_header unsafe.Pointer
	var wrap_arg_heights unsafe.Pointer
	var wrap_arg_areas unsafe.Pointer
	var wrap_arg_cons unsafe.Pointer
	var wrap_arg_outData unsafe.Pointer
	var wrap_arg_outDataSize unsafe.Pointer
	wrap_arg_comp = (unsafe.Pointer)(comp)
	wrap_arg_header = (unsafe.Pointer)(header)
	wrap_arg_heights = (unsafe.Pointer)(heights)
	wrap_arg_areas = (unsafe.Pointer)(areas)
	wrap_arg_cons = (unsafe.Pointer)(cons)
	wrap_arg_outData = (unsafe.Pointer)(outData)
	wrap_arg_outDataSize = (unsafe.Pointer)(outDataSize)
	wrap_out := C.nav_dtBuildTileCacheLayer(wrap_arg_comp, wrap_arg_header, wrap_arg_heights, wrap_arg_areas, wrap_arg_cons, wrap_arg_outData, wrap_arg_outDataSize)
	go_out := uint32(wrap_out)
	return go_out
}

/*
dtStatus dtBuildTileCachePolyMesh(dtTileCacheAlloc * alloc, dtTileCacheContourSet& lcset, dtTileCachePolyMesh& mesh)
*/
func DtBuildTileCachePolyMesh(alloc DtTileCacheAllocPtr, lcset DtTileCacheContourSetPtr, mesh DtTileCachePolyMeshPtr) uint32 {
	var wrap_arg_alloc unsafe.Pointer
	var wrap_arg_lcset unsafe.Pointer
	var wrap_arg_mesh unsafe.Pointer
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_arg_lcset = (unsafe.Pointer)(lcset)
	wrap_arg_mesh = (unsafe.Pointer)(mesh)
	wrap_out := C.nav_dtBuildTileCachePolyMesh(wrap_arg_alloc, wrap_arg_lcset, wrap_arg_mesh)
	go_out := uint32(wrap_out)
	return go_out
}

/*
dtStatus dtBuildTileCacheRegions(dtTileCacheAlloc * alloc, dtTileCacheLayer& layer, int const walkableClimb)
*/
func DtBuildTileCacheRegions(alloc DtTileCacheAllocPtr, layer DtTileCacheLayerPtr, walkableClimb int32) uint32 {
	var wrap_arg_alloc unsafe.Pointer
	var wrap_arg_layer unsafe.Pointer
	var wrap_arg_walkableClimb C.int
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_arg_layer = (unsafe.Pointer)(layer)
	wrap_arg_walkableClimb = (C.int)(walkableClimb)
	wrap_out := C.nav_dtBuildTileCacheRegions(wrap_arg_alloc, wrap_arg_layer, wrap_arg_walkableClimb)
	go_out := uint32(wrap_out)
	return go_out
}

/*
dtStatus dtDecompressTileCacheLayer(dtTileCacheAlloc * alloc, dtTileCacheCompressor * comp, unsigned char * compressed, int const compressedSize, dtTileCacheLayer * * layerOut)
*/
func DtDecompressTileCacheLayer(alloc DtTileCacheAllocPtr, comp DtTileCacheCompressorPtr, compressed *uint8, compressedSize int32, layerOut *DtTileCacheLayerPtr) uint32 {
	var wrap_arg_alloc unsafe.Pointer
	var wrap_arg_comp unsafe.Pointer
	var wrap_arg_compressed unsafe.Pointer
	var wrap_arg_compressedSize C.int
	var wrap_arg_layerOut unsafe.Pointer
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_arg_comp = (unsafe.Pointer)(comp)
	wrap_arg_compressed = (unsafe.Pointer)(compressed)
	wrap_arg_compressedSize = (C.int)(compressedSize)
	wrap_arg_layerOut = (unsafe.Pointer)(layerOut)
	wrap_out := C.nav_dtDecompressTileCacheLayer(wrap_arg_alloc, wrap_arg_comp, wrap_arg_compressed, wrap_arg_compressedSize, wrap_arg_layerOut)
	go_out := uint32(wrap_out)
	return go_out
}

/*
void dtFreeTileCacheContourSet(dtTileCacheAlloc * alloc, dtTileCacheContourSet * cset)
*/
func DtFreeTileCacheContourSet(alloc DtTileCacheAllocPtr, cset DtTileCacheContourSetPtr) {
	var wrap_arg_alloc unsafe.Pointer
	var wrap_arg_cset unsafe.Pointer
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_arg_cset = (unsafe.Pointer)(cset)
	C.nav_dtFreeTileCacheContourSet(wrap_arg_alloc, wrap_arg_cset)
}

/*
void dtFreeTileCacheLayer(dtTileCacheAlloc * alloc, dtTileCacheLayer * layer)
*/
func DtFreeTileCacheLayer(alloc DtTileCacheAllocPtr, layer DtTileCacheLayerPtr) {
	var wrap_arg_alloc unsafe.Pointer
	var wrap_arg_layer unsafe.Pointer
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_arg_layer = (unsafe.Pointer)(layer)
	C.nav_dtFreeTileCacheLayer(wrap_arg_alloc, wrap_arg_layer)
}

/*
void dtFreeTileCachePolyMesh(dtTileCacheAlloc * alloc, dtTileCachePolyMesh * lmesh)
*/
func DtFreeTileCachePolyMesh(alloc DtTileCacheAllocPtr, lmesh DtTileCachePolyMeshPtr) {
	var wrap_arg_alloc unsafe.Pointer
	var wrap_arg_lmesh unsafe.Pointer
	wrap_arg_alloc = (unsafe.Pointer)(alloc)
	wrap_arg_lmesh = (unsafe.Pointer)(lmesh)
	C.nav_dtFreeTileCachePolyMesh(wrap_arg_alloc, wrap_arg_lmesh)
}

/*
dtStatus dtMarkBoxArea(dtTileCacheLayer& layer, float const * orig, float const cs, float const ch, float const * bmin, float const * bmax, unsigned char const areaId)
*/
func DtMarkBoxArea(layer DtTileCacheLayerPtr, orig *float32, cs float32, ch float32, bmin *float32, bmax *float32, areaId uint8) uint32 {
	var wrap_arg_layer unsafe.Pointer
	var wrap_arg_orig unsafe.Pointer
	var wrap_arg_cs C.float
	var wrap_arg_ch C.float
	var wrap_arg_bmin unsafe.Pointer
	var wrap_arg_bmax unsafe.Pointer
	var wrap_arg_areaId C.uchar
	wrap_arg_layer = (unsafe.Pointer)(layer)
	wrap_arg_orig = (unsafe.Pointer)(orig)
	wrap_arg_cs = (C.float)(cs)
	wrap_arg_ch = (C.float)(ch)
	wrap_arg_bmin = (unsafe.Pointer)(bmin)
	wrap_arg_bmax = (unsafe.Pointer)(bmax)
	wrap_arg_areaId = (C.uchar)(areaId)
	wrap_out := C.nav_dtMarkBoxArea(wrap_arg_layer, wrap_arg_orig, wrap_arg_cs, wrap_arg_ch, wrap_arg_bmin, wrap_arg_bmax, wrap_arg_areaId)
	go_out := uint32(wrap_out)
	return go_out
}

/*
dtStatus dtMarkBoxArea(dtTileCacheLayer& layer, float const * orig, float const cs, float const ch, float const * center, float const * halfExtents, float const * rotAux, unsigned char const areaId)
*/
func DtMarkBoxArea11(layer DtTileCacheLayerPtr, orig *float32, cs float32, ch float32, center *float32, halfExtents *float32, rotAux *float32, areaId uint8) uint32 {
	var wrap_arg_layer unsafe.Pointer
	var wrap_arg_orig unsafe.Pointer
	var wrap_arg_cs C.float
	var wrap_arg_ch C.float
	var wrap_arg_center unsafe.Pointer
	var wrap_arg_halfExtents unsafe.Pointer
	var wrap_arg_rotAux unsafe.Pointer
	var wrap_arg_areaId C.uchar
	wrap_arg_layer = (unsafe.Pointer)(layer)
	wrap_arg_orig = (unsafe.Pointer)(orig)
	wrap_arg_cs = (C.float)(cs)
	wrap_arg_ch = (C.float)(ch)
	wrap_arg_center = (unsafe.Pointer)(center)
	wrap_arg_halfExtents = (unsafe.Pointer)(halfExtents)
	wrap_arg_rotAux = (unsafe.Pointer)(rotAux)
	wrap_arg_areaId = (C.uchar)(areaId)
	wrap_out := C.nav_dtMarkBoxArea11(wrap_arg_layer, wrap_arg_orig, wrap_arg_cs, wrap_arg_ch, wrap_arg_center, wrap_arg_halfExtents, wrap_arg_rotAux, wrap_arg_areaId)
	go_out := uint32(wrap_out)
	return go_out
}

/*
dtStatus dtMarkCylinderArea(dtTileCacheLayer& layer, float const * orig, float const cs, float const ch, float const * pos, float const radius, float const height, unsigned char const areaId)
*/
func DtMarkCylinderArea(layer DtTileCacheLayerPtr, orig *float32, cs float32, ch float32, pos *float32, radius float32, height float32, areaId uint8) uint32 {
	var wrap_arg_layer unsafe.Pointer
	var wrap_arg_orig unsafe.Pointer
	var wrap_arg_cs C.float
	var wrap_arg_ch C.float
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_radius C.float
	var wrap_arg_height C.float
	var wrap_arg_areaId C.uchar
	wrap_arg_layer = (unsafe.Pointer)(layer)
	wrap_arg_orig = (unsafe.Pointer)(orig)
	wrap_arg_cs = (C.float)(cs)
	wrap_arg_ch = (C.float)(ch)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_radius = (C.float)(radius)
	wrap_arg_height = (C.float)(height)
	wrap_arg_areaId = (C.uchar)(areaId)
	wrap_out := C.nav_dtMarkCylinderArea(wrap_arg_layer, wrap_arg_orig, wrap_arg_cs, wrap_arg_ch, wrap_arg_pos, wrap_arg_radius, wrap_arg_height, wrap_arg_areaId)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Swaps the endianness of the compressed tile data's header (#dtTileCacheLayerHeader).
Tile layer data does not need endian swapping as it consist only of bytes.

@param data The tile data array.
@param dataSize The size of the data array.

bool dtTileCacheHeaderSwapEndian(unsigned char * data, int const dataSize)
*/
func DtTileCacheHeaderSwapEndian(data *uint8, dataSize int32) bool {
	var wrap_arg_data unsafe.Pointer
	var wrap_arg_dataSize C.int
	wrap_arg_data = (unsafe.Pointer)(data)
	wrap_arg_dataSize = (C.int)(dataSize)
	wrap_out := C.nav_dtTileCacheHeaderSwapEndian(wrap_arg_data, wrap_arg_dataSize)
	go_out := bool(wrap_out)
	return go_out
}

/*
dtTileCacheAlloc * NewDtTileCacheAllocPtrArray(long n)
*/
func NewDtTileCacheAllocPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCacheAllocPtr]] {
	wrap_out := C.nav_NewDtTileCacheAllocPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCacheAllocPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtTileCacheContour * NewDtTileCacheContourPtrArray(long n)
*/
func NewDtTileCacheContourPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCacheContourPtr]] {
	wrap_out := C.nav_NewDtTileCacheContourPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCacheContourPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtTileCacheContourSet * NewDtTileCacheContourSetPtrArray(long n)
*/
func NewDtTileCacheContourSetPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCacheContourSetPtr]] {
	wrap_out := C.nav_NewDtTileCacheContourSetPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCacheContourSetPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtTileCacheLayerHeader * NewDtTileCacheLayerHeaderPtrArray(long n)
*/
func NewDtTileCacheLayerHeaderPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCacheLayerHeaderPtr]] {
	wrap_out := C.nav_NewDtTileCacheLayerHeaderPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCacheLayerHeaderPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtTileCacheLayer * NewDtTileCacheLayerPtrArray(long n)
*/
func NewDtTileCacheLayerPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCacheLayerPtr]] {
	wrap_out := C.nav_NewDtTileCacheLayerPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCacheLayerPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtTileCachePolyMesh * NewDtTileCachePolyMeshPtrArray(long n)
*/
func NewDtTileCachePolyMeshPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtTileCachePolyMeshPtr]] {
	wrap_out := C.nav_NewDtTileCachePolyMeshPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtTileCachePolyMeshPtr]]](uintptr(wrap_out))
	return go_out
}
